Nets in Nets with SNAKES

International audienceThis paper presents the toolkit SNAKES, focusing on the ability to model Petri nets whose tokens are Petri nets (so called nets in nets). SNAKES is a general Petri net library that allows to model and execute Python-coloured Petri nets: tokens are Python objects and net inscriptions are Python expressions. Since SNAKES itself is programmed in Python, Petri net inscriptions can handle Petri net objects as data values, for instance as tokens

Modelling, Verification, and Formal Analysis of Security Properties in a P2P System

International audienceWe present a security analysis of the SPREADS 1 system, a distributed storage service based on a centralized peer-to-peer architecture. We formally modelled the salient behavior of the actual system using ABCD, a high level specification language with a coloured Petri net semantics, which allowed the execution states of the system to be verified. We verified the behavior of the system in the presence of an external Dolev-Yao attacker, unearthing some replay attacks in the original system. Furthermore, since the implementation is also a formal model, we have been able to show that any execution of the model satisfies certain desirable security properties once these flaws are repaired

Fine-grained Locality-aware Parallel Scheme for Anisotropic Mesh Adaptation

AbstractIn this paper, we provide a fine-grained parallel scheme for anisotropic mesh adaptation on NUMA11Non-Uniform Memory Access architectures.Data dependencies are expressed by a graph for each kernel, and concurrency is extracted through fine-grained graph coloring. Tasks are structured into bulk-synchronous steps to avoid data races and to aggregate shared-data accesses.To ensure performance prediction, time cost and load imbalance are theoretically characterized.The devised scheme was evaluated on a 4 NUMA node (2-socket) machine, and a mean efficiency of 70% was reached on 32 cores for 3 kernels out of 4. The impact of irregular degree distribution and data layout on scalability is highlighted

Proving a Petri net model-checker implementation

Petri nets are a widely used tool in verification through model-checking. In this approach, a Petri Net model of the system of interest is produced and its reachable states are computed, searching for erroneous executions. Compilation of such a Petri net model is one way to accelerate its verification. It consists in generating code to explore the reachable states of the considered Petri net, which avoids the use of a fixed exploration tool involving an "interpretation" of the Petri net structure. In this paper, we show how to compile Petri nets targeting the LLVM language (a high-level assembly language) and formally prove the correct-ness of the produced code. To this aim, we define a structural operational semantics for the fragment of LLVM we use. The acceleration obtained from the presented compilation techniques has been evaluated in [6]

Faster simulation of (Coloured) Petri nets using parallel computing

International audienceFast simulation, i.e., automatic computation of sequential runs, is widely used to analyse Petri nets. In particular, it enables for quantitative statistical analysis by observing large sets of runs. Moreover, fast simulation may be used to actually run a Petri net model as a (prototype) implementation of a system, in which case such a net would embed fragments of the code of the system. In both these contexts, being able to perform faster simulation is highly desirable. In this paper, we propose a way to accelerate fast simulation by exploiting parallel computing, targeting both the multi-core cpus available nowadays in every laptop or workstation, and larger parallel computers including those with distributed memory (clusters). We design an algorithm to do so and assess in particular its correctness and completeness through its formal modelling as a Petri net whose state space is analysed. We also present a benchmark of a prototype implementation that clearly shows how our algorithm effectively accelerates fast simulation, in particular in the case of large concurrent coloured Petri nets, which is precisely the kind of nets that are usually slow to simulate

Modular µ-calculus model-checking with formula-dependent hierarchical abstractions

International audienceThis paper defines a formal framework for the modular and hierarchical model-checking of µ-calculus against modular transitions systems. Given a formula ϕ, a module can be analysed alone, in such a way that the truth value of ϕ may be decided without the need to analyse other modules. If no conclusion can be drawn locally, the analysis provides information allowing to reduce the module to a smaller one that is equivalent with respect to the truth value of ϕ. This way, modules can be incrementally analysed, reduced and composed to other reduced modules until a conclusion is reached. On the one hand, modular analysis allows to avoid modules compositions and thus the corresponding combinatorial explosion; on the other hand, hierarchical analysis allows to reduce the modules that must be composed, which limits combinatorial explosion. Moreover, by proposing three complementary formula-dependent reductions, we expect better reductions than general approaches like bisimulation or τ * reductions. The current paper is focused on defining the theoretical tools for this approach; finding interesting strategies to apply them efficiently is left to future work

Proceedings of SUMo and CompoNet 2011

International audienc

A BSP Algorithm for the State Space Construction of Security Protocols

International audienceThis paper presents a Bulk-Synchronous Parallel (BSP) algorithm to compute the discrete state space of structured models of security protocols. The BSP model of parallelism avoids concurrency related problems (mainly deadlocks and non-determinism) and allows us to design an efficient algorithm that is at the same time simple to express. A prototype implementation has been developed, allowing to run benchmarks showing the benefits of our algorithm

A modular, qualitative modelling of regulatory networks using Petri nets

International audienceAdvances in high-throughput technologies have enabled the de-lineation of large networks of interactions that control cellular processes. To understand behavioural properties of these complex networks, mathematical and computational tools are required. The multi-valued logical formalism, initially defined by R. Thomas and co-workers, proved well adapted to account for the qualitative knowledge available on regulatory interactions, and also to perform analyses of their dynamical properties. In this context, we present two representations of logical models in terms of Petri nets. In a first step, we briefly show how logical models of regulatory networks can be transposed into standard (place/transition) Petri nets, and discuss the capabilities of such representation. In the second part, we focus on logical regulatory modules and their composition, demonstrating that a high-level Petri net representation greatly facilitates the modelling of interconnected modules. Doing so, we introduce an explicit means to integrate signals from various interconnected modules, taking into account their spatial distribution. This provides a flexible modelling framework to handle regulatory networks that operate at both intra-and intercellular levels. As an illustration, we describe a simplified model of the segment-polarity module involved in the segmentation of the Drosophila embryo

Efficient Reachability Graph Representation of Petri Nets With Unbounded Counters

AbstractIn this paper, we define a class of Petri nets, called Petri nets with counters, that can be seen as place/transition Petri nets enriched with a vector of integer variables on which linear operations may be applied. Their semantics usually leads to huge or infinite reachability graphs. Then, a more compact representation for this semantics is defined as a symbolic state graph whose nodes possibly encode infinitely many values for the variables. Both representations are shown behaviourally equivalent